<!DOCTYPE html>
<html lang="zh-CN">





<head>
  <meta charset="UTF-8">
  <link rel="apple-touch-icon" sizes="76x76" href="/img/apple-touch-icon.png">
  <link rel="icon" type="image/png" href="/img/favicon.png">
  <meta name="viewport"
        content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, shrink-to-fit=no">
  <meta http-equiv="x-ua-compatible" content="ie=edge">
  
  <meta name="description" content="">
  <meta name="author" content="Mrtutu">
  <meta name="keywords" content="">
  <title>卷积神经网络 ~ Mrtutu</title>

  <link rel="stylesheet" href="/lib/font-awesome/css/all.min.css"  >
<link rel="stylesheet" href="/lib/bootstrap/css/bootstrap.min.css"  >
<link rel="stylesheet" href="/lib/mdbootstrap/css/mdb.min.css"  >
<link rel="stylesheet" href="/lib/github-markdown/github-markdown.min.css"  >

<link rel="stylesheet" href="//at.alicdn.com/t/font_1067060_qzomjdt8bmp.css">



  <link rel="stylesheet" href="/lib/prettify/tomorrow-night-eighties.min.css"  >

<link rel="stylesheet" href="/css/main.css"  >


  <link rel="stylesheet" href="/lib/fancybox/jquery.fancybox.min.css"  >


<meta name="generator" content="Hexo 4.2.0"></head>


<body>
  <header style="height: 80vh;">
    <nav id="navbar" class="navbar fixed-top  navbar-expand-lg navbar-dark scrolling-navbar">
  <div class="container">
    <a class="navbar-brand"
       href="/">&nbsp;<strong>Mrtutu</strong>&nbsp;</a>

    <button id="navbar-toggler-btn" class="navbar-toggler" type="button" data-toggle="collapse"
            data-target="#navbarSupportedContent"
            aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
      <div class="animated-icon"><span></span><span></span><span></span></div>
    </button>

    <!-- Collapsible content -->
    <div class="collapse navbar-collapse" id="navbarSupportedContent">
      <ul class="navbar-nav ml-auto text-center">
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/">首页</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/archives/">归档</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/categories/">分类</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/tags/">标签</a>
          </li>
        
          
          
          
          
          <li class="nav-item">
            <a class="nav-link" href="/about/">关于</a>
          </li>
        
        
          <li class="nav-item" id="search-btn">
            <a class="nav-link" data-toggle="modal" data-target="#modalSearch">&nbsp;&nbsp;<i
                class="iconfont icon-search"></i>&nbsp;&nbsp;</a>
          </li>
        
      </ul>
    </div>
  </div>
</nav>

    <div class="view intro-2" id="background" false
         style="background: url('/img/2.png')no-repeat center center;
           background-size: cover;">
      <div class="full-bg-img">
        <div class="mask rgba-black-light flex-center">
          <div class="container text-center white-text fadeInUp">
            <span class="h2" id="subtitle">
              
            </span>

            
              <br>
              
                <p class="mt-3">
                  <i class="fas fa-calendar-alt" aria-hidden="true"></i>&nbsp;
                  星期六, 三月 7日 2020, 1:24 下午
                </p>
              

              <p>
                
                  
                  &nbsp;<i class="far fa-chart-bar"></i>
                  <span class="post-count">
                    7.6k 字
                  </span>&nbsp;
                

                
                  
                  &nbsp;<i class="far fa-clock"></i>
                  <span class="post-count">
                      29 分钟
                  </span>&nbsp;
                

                
                  <!-- 不蒜子统计文章PV -->
                  
                  &nbsp;<i class="far fa-eye" aria-hidden="true"></i>&nbsp;
                  <span id="busuanzi_container_page_pv">
                    <span id="busuanzi_value_page_pv"></span> 次
                  </span>&nbsp;
                
              </p>
            
          </div>

          
        </div>
      </div>
    </div>
  </header>

  <main>
    
      

<div class="container-fluid">
  <div class="row">
    <div class="d-none d-lg-block col-lg-2"></div>
    <div class="col-lg-8 nopadding-md">
      <div class="py-5 z-depth-3" id="board">
        <div class="post-content mx-auto" id="post">
          <div class="markdown-body">
            <p>（文章来源：Baidu AI Studio）<br>计算机视觉作为一门让机器学会如何去“看”的科学学科，具体的说，就是让机器去识别摄像机拍摄的图片或视频中的物体，检测出物体所在的位置，并对目标物体进行跟踪，从而理解并描述出图片或视频里的场景和故事，以此来模拟人脑视觉系统。因此，计算机视觉也通常被叫做机器视觉，其目的是建立能够从图像或者视频中“感知”信息的人工系统。</p>
<p>计算机视觉技术经过几十年的发展，已经在交通（车牌识别、道路违章抓拍）、安防（人脸闸机、小区监控）、金融（刷脸支付、柜台的自动票据识别）、医疗（医疗影像诊断）、工业生产（产品缺陷自动检测）等多个领域应用，影响或正在改变人们的日常生活和工业生产方式。未来，随着技术的不断演进，必将涌现出更多的产品应用，为我们的生活创造更大的便利和更广阔的机会。<br><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/7551003e81ba4f879c1633c625e69ed57b938ab4c1df4f968f0108dd7bff5a1a" srcset="/img/loading.gif" width="800"></center></p>
<p><center><br>图1：计算机视觉技术在各领域的应用<br></center><br><br><br></p>
<p>飞桨为计算机视觉任务提供了丰富的API，并通过底层优化和加速保证了这些API的性能。同时，飞桨还提供了丰富的模型库，覆盖图像分类、检测、分割、文字识别和视频理解等多个领域。用户可以直接使用这些API组建模型，也可以在飞桨提供的模型库基础上进行二次研发。</p>
<p>由于篇幅所限，本章将重点介绍计算机视觉的两个典型任务：图像分类和目标检测。主要涵盖如下内容：</p>
<ul>
<li><p><strong>卷积神经网络</strong>：卷积神经网络（Convolutional Neural Networks, CNN）是计算机视觉技术最经典的模型结构。这里主要介绍卷积神经网络的常用模块，包括：卷积、池化等。</p>
</li>
<li><p><strong>图像分类</strong>：介绍图像分类算法的经典模型结构，并通过眼疾筛查的案例展示算法的应用。</p>
</li>
<li><p><strong>目标检测</strong>：介绍目标检测YOLO-V3算法，并通过林业病虫害数据集中的虫子检测任务案例展示YOLO-V3算法的应用。</p>
</li>
</ul>
<h1 id="计算机视觉发展历程"><a href="#计算机视觉发展历程" class="headerlink" title="计算机视觉发展历程"></a>计算机视觉发展历程</h1><p>介绍卷积神经网络之前，我们先回顾一下计算机视觉发展历程，这要从生物视觉讲起。</p>
<p>对于生物视觉的形成时间，目前学术界尚没有形成定论，有研究者认为最早的生物视觉形成于距今约<a href="https://www.pnas.org/content/109/46/18868" target="_blank" rel="noopener">7亿年前的水母之中</a>，也有研究者认为生物视觉产生于距今约5亿年前寒武纪【<a href="https://doi.org/10.1038%2Fnature10097" target="_blank" rel="noopener">1</a>, <a href="https://en.wikipedia.org/wiki/Evolution_of_the_eye" target="_blank" rel="noopener">2</a>】。寒武纪生物大爆发的原因一直是个未解之谜，不过可以肯定的是在寒武纪动物具有了视觉能力，捕食者可以更容易的发现猎物，被捕食者也可以更早的发现天敌的位置。视觉能力加剧了猎手和猎物之间的博弈，也催生出更加激烈的生存演化规则。视觉系统的形成有力的推动了食物链的演化，加速了生物进化过程，是生物发展史上重要的里程碑。经过几亿年的演化，目前人类的视觉系统已经具备非常高的复杂度和强大的功能，人脑中神经元数目达到了1000亿个，这些神经元通过网络互相连接，这样庞大的视觉神经网络使得我们可以很轻松的观察周围的世界。</p>
<p>对人类来说，识别猫和狗是件非常容易的事。但对计算机来说，即使是一个精通编程的高手，也很难轻松写出具有通用性的程序（比如：假设程序认为体型大的是狗，体型小的是猫，但由于拍摄角度不同，可能一张图片上猫占据的像素比狗还多）。那么，如何让计算机也能像人一样看懂周围的世界呢？研究者尝试着从不同的角度去解决这个问题，由此也发展出一系列的子任务，如 <strong>图2</strong> 所示。</p>
<p><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/d65f1ebcb0054dcb81a8eb50223adc529bb9b63265ab467d931a5df5b2864122" srcset="/img/loading.gif" width="600"></center></p>
<p><center><br>图2：计算机视觉子任务示意图<br></center><br><br><br></p>
<ul>
<li><p><strong>(a) Image Classification：</strong> 图像分类，用于识别图像中物体的类别（如：bottle、cup、cube）</p>
</li>
<li><p><strong>(b) Object Localization：</strong> 目标检测，用于检测图像中每个物体的类别，并准确标出它们的位置。</p>
</li>
<li><p><strong>(c) Semantic Segmentation：</strong> 图像语义分割，用于标出图像中每个像素点所属的类别，属于同一类别的像素点用一个颜色标识。</p>
</li>
<li><p><strong>(d) Instance Segmentation：</strong> 实例分割，值得注意的是，（b）中的目标检测任务只需要标注出物体位置，而（d）中的实例分割任务不仅要标注出物体位置，还需要标注出物体的外形轮廓。</p>
</li>
</ul>
<p>在早期的图像分类任务中，通常是先人工提取图像特征，再用机器学习算法对这些特征进行分类，分类的结果强依赖于特征提取方法，往往只有经验丰富的研究者才能完成。在这种背景下，基于神经网络的特征提取方法应运而生。Yan LeCun是最早将卷积神经网络应用到图像识别领域的，其主要逻辑是使用卷积神经网络提取图像特征，并对图像所属类别进行预测，通过训练数据不断调整网络参数，最终形成一套能自动提取图像特征并对这些特征进行分类的网络。这一方法在手写数字识别任务上取得了极大的成功，但在接下来的时间里，却没有得到很好的发展。其主要原因一方面是数据集不完善，只能处理简单任务，在大尺寸的数据上容易发生过拟合；另一方面是硬件瓶颈，网络模型复杂时，计算速度会特别慢。</p>
<p>目前，随着互联网技术的不断进步，数据量呈现大规模的增长，越来越丰富的数据集不断涌现。另外，得益于硬件能力的提升，计算机的算力也越来越强大。不断有研究者将新的模型和算法应用到计算机视觉领域。由此催生了越来越丰富的模型结构和更加准确的精度，同时计算机视觉所处理的问题也越来越丰富，包括分类、检测、分割、场景描述、图像生成和风格变换等，甚至还不仅仅局限于2维图片，包括视频处理技术和3D视觉等。</p>
<h1 id="卷积神经网络"><a href="#卷积神经网络" class="headerlink" title="卷积神经网络"></a>卷积神经网络</h1><p>卷积神经网络是目前计算机视觉中使用最普遍的模型结构。本章节主要为读者介绍卷积神经网络的一些基础模块，包括：</p>
<ul>
<li>卷积（Convolution）</li>
<li>池化（Pooling）</li>
<li>ReLU激活函数</li>
<li>批归一化（Batch Normalization）</li>
<li>丢弃法（Dropout）</li>
</ul>
<p>回顾一下，在上一章“一个案例带你吃透深度学习”中，我们介绍了手写数字识别任务，应用的是全连接层的特征提取，即将一张图片上的所有像素点展开成一个1维向量输入网络，存在如下两个问题：</p>
<p><strong>1. 输入数据的空间信息被丢失。</strong> 空间上相邻的像素点往往具有相似的RGB值，RGB的各个通道之间的数据通常密切相关，但是转化成1维向量时，这些信息被丢失。同时，图像数据的形状信息中，可能隐藏着某种本质的模式，但是转变成1维向量输入全连接神经网络时，这些模式也会被忽略。</p>
<p><strong>2. 模型参数过多，容易发生过拟合。</strong> 在手写数字识别案例中，每个像素点都要跟所有输出的神经元相连接。当图片尺寸变大时，输入神经元的个数会按图片尺寸的平方增大，导致模型参数过多，容易发生过拟合。</p>
<p>为了解决上述问题，我们引入卷积神经网络进行特征提取，既能提取到像相邻素点之间的特征模式，又能保证参数的个数不随图片尺寸变化。<strong>图3</strong> 是一个典型的卷积神经网络结构，多层卷积和池化层组合作用在输入图片上，在网络的最后通常会加入一系列全连接层，ReLU激活函数一般加在卷积或者全连接层的输出上，网络中通常还会加入Dropout来防止过拟合。</p>
<p><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/d09ea1f8a785400fafb334db57f1dc5e796f3f20aa5c40c697ccf9e41a6e4044" srcset="/img/loading.gif" width="800"></center></p>
<p><center><br>图3：卷积神经网络经典结构<br></center><br><br><br></p>
<hr>
<p><strong>说明：</strong></p>
<p>在卷积神经网络中，计算范围是在像素点的空间邻域内进行的，卷积核参数的数目也远小于全连接层。卷积核本身与输入图片大小无关，它代表了对空间临域内某种特征模式的提取。比如，有些卷积核提取物体边缘特征，有些卷积核提取物体拐角处的特征，图像上不同区域共享同一个卷积核。当输入图片大小不一样时，仍然可以使用同一个卷积核进行操作。</p>
<hr>
<h2 id="卷积（Convolution）"><a href="#卷积（Convolution）" class="headerlink" title="卷积（Convolution）"></a>卷积（Convolution）</h2><p>这一小节将为读者介绍卷积算法的原理和实现方案，并通过具体的案例展示如何使用卷积对图片进行操作，主要涵盖如下内容：</p>
<ul>
<li><p>卷积计算</p>
</li>
<li><p>填充（padding）</p>
</li>
<li><p>步幅（stride）</p>
</li>
<li><p>感受野（Receptive Field）</p>
</li>
<li><p>多输入通道、多输出通道和批量操作</p>
</li>
<li><p>飞桨卷积API介绍</p>
</li>
<li><p>卷积算子应用举例</p>
</li>
</ul>
<h3 id="卷积计算"><a href="#卷积计算" class="headerlink" title="卷积计算"></a>卷积计算</h3><p>卷积是数学分析中的一种积分变化的方法，在图像处理中采用的是卷积的离散形式。这里需要说明的是，在卷积神经网络中，卷积层的实现方式实际上是数学中定义的互相关  （cross-correlation）运算，与数学分析中的卷积定义有所不同，这里跟其他框架和卷积神经网络的教程保持一致，都使用互相关运算作为卷积的定义，具体的计算过程如 <strong>图4</strong> 所示。</p>
<p><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/01b2b83774b44804b14191c254d1f7ed1f55bb7660714738bde8fae94ab277d0" srcset="/img/loading.gif" width="700"></center></p>
<p><center><br>图4：卷积计算过程<br></center><br><br><br></p>
<hr>
<p><strong>说明：</strong></p>
<p>卷积核（kernel）也被叫做滤波器（filter），假设卷积核的高和宽分别为$k_h$和$k_w$，则将称为$k_h\times k_w$卷积，比如$3\times5$卷积，就是指卷积核的高为3, 宽为5。</p>
<hr>
<ul>
<li>如图4（a）所示：左边的图大小是$3\times3$，表示输入数据是一个维度为$3\times3$的二维数组；中间的图大小是$2\times2$，表示一个维度为$2\times2$的二维数组，我们将这个二维数组称为卷积核。先将卷积核的左上角与输入数据的左上角（即：输入数据的(0, 0)位置）对齐，把卷积核的每个元素跟其位置对应的输入数据中的元素相乘，再把所有乘积相加，得到卷积输出的第一个结果</li>
</ul>
<script type="math/tex; mode=display">0\times1 + 1\times2 + 2\times4 + 3\times5 = 25  \ \ \ \ \ \ \ (a)</script><ul>
<li>如图4（b）所示：将卷积核向右滑动，让卷积核左上角与输入数据中的(0,1)位置对齐，同样将卷积核的每个元素跟其位置对应的输入数据中的元素相乘，再把这4个乘积相加，得到卷积输出的第二个结果，</li>
</ul>
<script type="math/tex; mode=display">0\times2 + 1\times3 + 2\times5 + 3\times6 = 31  \ \ \ \ \ \ \ (b)</script><ul>
<li>如图4（c）所示：将卷积核向下滑动，让卷积核左上角与输入数据中的(1, 0)位置对齐，可以计算得到卷积输出的第三个结果，</li>
</ul>
<script type="math/tex; mode=display">0\times4 + 1\times5 + 2\times7 + 3\times8 = 43   \ \ \ \ \ \ \ (c)</script><ul>
<li>如图4（d）所示：将卷积核向右滑动，让卷积核左上角与输入数据中的(1, 1)位置对齐，可以计算得到卷积输出的第四个结果，</li>
</ul>
<script type="math/tex; mode=display">0\times5 + 1\times6 + 2\times8 + 3\times9 = 49   \ \ \ \ \ \ \ (d)</script><p>卷积核的计算过程可以用下面的数学公式表示，其中 $a$ 代表输入图片， $b$ 代表输出特征图，$w$ 是卷积核参数，它们都是二维数组，$\sum{u,v}{\ }$ 表示对卷积核参数进行遍历并求和。</p>
<script type="math/tex; mode=display">b[i, j] = \sum_{u,v}{a[i+u, j+v]\cdot w[u, v]}</script><p>举例说明，假如上图中卷积核大小是$2\times 2$，则$u$可以取0和1，$v$也可以取0和1，也就是说：</p>
<script type="math/tex; mode=display">b[i, j] = a[i+0, j+0]\cdot w[0, 0] + a[i+0, j+1]\cdot w[0, 1] + a[i+1, j+0]\cdot w[1, 0] + a[i+1, j+1]\cdot w[1, 1]</script><p>读者可以自行验证，当$[i, j]$取不同值时，根据此公式计算的结果与上图中的例子是否一致。</p>
<ul>
<li><strong>【思考】 当卷积核大小为$3 \times 3$时，b和a之间的对应关系应该是怎样的？</strong></li>
</ul>
<hr>
<p><strong>其它说明：</strong></p>
<p>在卷积神经网络中，一个卷积算子除了上面描述的卷积过程之外，还包括加上偏置项的操作。例如假设偏置为1，则上面卷积计算的结果为：</p>
<script type="math/tex; mode=display">0\times1 + 1\times2 + 2\times4 + 3\times5 \mathbf{\  + 1}  = 26</script><script type="math/tex; mode=display">0\times2 + 1\times3 + 2\times5 + 3\times6 \mathbf{\  + 1} = 32</script><script type="math/tex; mode=display">0\times4 + 1\times5 + 2\times7 + 3\times8 \mathbf{\  + 1} = 44</script><script type="math/tex; mode=display">0\times5 + 1\times6 + 2\times8 + 3\times9 \mathbf{\  + 1} = 50</script><hr>
<h3 id="填充（padding）"><a href="#填充（padding）" class="headerlink" title="填充（padding）"></a>填充（padding）</h3><p>在上面的例子中，输入图片尺寸为$3\times3$，输出图片尺寸为$2\times2$，经过一次卷积之后，图片尺寸变小。卷积输出特征图的尺寸计算方法如下：</p>
<script type="math/tex; mode=display">H_{out} = H - k_h + 1</script><script type="math/tex; mode=display">W_{out} = W - w_h + 1</script><p>如果输入尺寸为4，卷积核大小为3时，输出尺寸为$4-3+1=2$。读者可以自行检查当输入图片和卷积核为其他尺寸时，上述计算式是否成立。通过多次计算我们发现，当卷积核尺寸大于1时，输出特征图的尺寸会小于输入图片尺寸。说明经过多次卷积之后尺寸会不断减小。为了避免卷积之后图片尺寸变小，通常会在图片的外围进行填充(padding)，如 <strong>图5</strong> 所示。</p>
<p><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/1bcb554f6cac4084945106a0cb75ff0c348108cc91c74781a3993bf89f5552d5" srcset="/img/loading.gif" width="700"></center></p>
<p><center><br>图5：图形填充 <br></center><br><br><br></p>
<ul>
<li><p>如图5（a）所示：填充的大小为1，填充值为0。填充之后，输入图片尺寸从$4\times4$变成了$6\times6$，使用3x3的卷积核，输出图片尺寸为$4\times4$。</p>
</li>
<li><p>如图5（b）所示：填充的大小为2，填充值为0。填充之后，输入图片尺寸从$4\times4$变成了$8\times8$，使用3x3的卷积核，输出图片尺寸为$6\times6$。</p>
</li>
</ul>
<p>如果在图片高度方向，在第一行之前填充$p<em>{h1}$行，在最后一行之后填充$p</em>{h2}$行；在图片的宽度方向，在第1列之前填充$p<em>{w1}$列，在最后1列之后填充$p</em>{w2}$列；则填充之后的图片尺寸为$(H + p<em>{h1} + p</em>{h2})\times(W + p<em>{w1} + p</em>{w2})$。经过大小为$k_h\times k_w$的卷积核操作之后，输出图片的尺寸为：</p>
<script type="math/tex; mode=display">H_{out} = H + p_{h1} + p_{h2} - k_h + 1</script><script type="math/tex; mode=display">W_{out} = W + p_{w1} + p_{w2} - k_w + 1</script><p>在卷积计算过程中，通常会在高度或者宽度的两侧采取等量填充，即$p<em>{h1} = p</em>{h2} = p<em>h,\ \ p</em>{w1} = p_{w2} = p_w$，上面计算公式也就变为：</p>
<script type="math/tex; mode=display">H_{out} = H + 2p_h - k_h + 1</script><script type="math/tex; mode=display">W_{out} = W + 2p_w - k_w + 1</script><p>卷积核大小通常使用1，3，5，7这样的奇数，如果使用的填充大小为$p_h=(k_h-1)/2, p_w=(k_w-1)/2$，则卷积之后图像尺寸不变。例如当卷积核大小为3时，padding大小为1，卷积之后图像尺寸不变；同理，如果卷积核大小为5，使用padding的大小为2，也能保持图像尺寸不变。</p>
<h3 id="步幅（stride）"><a href="#步幅（stride）" class="headerlink" title="步幅（stride）"></a>步幅（stride）</h3><p><strong>图5</strong> 中卷积核每次滑动一个像素点，这是步幅为1的特殊情况。<strong>图6</strong> 是步幅为2的卷积过程，卷积核在图片上移动时，每次移动大小为2个像素点。<br><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/2b9a1d03ff264dc1b0901b3eeee3637c49cd55ba07e64a2d9887ad90a4292742" srcset="/img/loading.gif" width="800"></center></p>
<p><center><br>图6：步幅为2的卷积过程 <br></center><br><br><br></p>
<p>当宽和高方向的步幅分别为$s_h$和$s_w$时，输出特征图尺寸的计算公式是：</p>
<script type="math/tex; mode=display">H_{out} = \frac{H + 2p_h - k_h}{s_h} + 1</script><script type="math/tex; mode=display">W_{out} = \frac{W + 2p_w - k_w}{s_w} + 1</script><p>假设输入图片尺寸是$H\times W = 100 \times 100$，卷积核大小$k_h \times k_w = 3 \times 3$，填充$p_h = p_w = 1$，步幅为$s_h = s_w = 2$，则输出特征图的尺寸为：</p>
<script type="math/tex; mode=display">H_{out} = \frac{100 + 2 - 3}{2} + 1 = 50</script><script type="math/tex; mode=display">W_{out} = \frac{100 + 2 - 3}{2} + 1 = 50</script><h3 id="感受野（Receptive-Field）"><a href="#感受野（Receptive-Field）" class="headerlink" title="感受野（Receptive Field）"></a>感受野（Receptive Field）</h3><p>输出特征图上每个点的数值，是由输入图片上大小为$k_h\times k_w$的区域的元素与卷积核每个元素相乘再相加得到的，所以输入图像上$k_h\times k_w$区域内每个元素数值的改变，都会影响输出点的像素值。我们将这个区域叫做输出特征图上对应点的感受野。感受野内每个元素数值的变动，都会影响输出点的数值变化。比如$3\times3$卷积对应的感受野大小就是$3\times3$。</p>
<h3 id="多输入通道、多输出通道和批量操作"><a href="#多输入通道、多输出通道和批量操作" class="headerlink" title="多输入通道、多输出通道和批量操作"></a>多输入通道、多输出通道和批量操作</h3><p>前面介绍的卷积计算过程比较简单，实际应用时，处理的问题要复杂的多。例如：对于彩色图片有RGB三个通道，需要处理多输入通道的场景。输出特征图往往也会具有多个通道，而且在神经网络的计算中常常是把一个批次的样本放在一起计算，所以卷积算子需要具有批量处理多输入和多输出通道数据的功能，下面将分别介绍这几种场景的操作方式。</p>
<ul>
<li><strong>多输入通道场景</strong></li>
</ul>
<p>上面的例子中，卷积层的数据是一个2维数组，但实际上一张图片往往含有RGB三个通道，要计算卷积的输出结果，卷积核的形式也会发生变化。假设输入图片的通道数为$C<em>{in}$，输入数据的形状是$C</em>{in}\times{H<em>{in}}\times{W</em>{in}}$，计算过程如 <strong>图7</strong> 所示。</p>
<ol>
<li><p>对每个通道分别设计一个2维数组作为卷积核，卷积核数组的形状是$C_{in}\times{k_h}\times{k_w}$。</p>
</li>
<li><p>对任一通道$c<em>{in} \in [0, C</em>{in})$，分别用大小为$k<em>h\times{k_w}$的卷积核在大小为$H</em>{in}\times{W_{in}}$的二维数组上做卷积。</p>
</li>
<li><p>将这$C<em>{in}$个通道的计算结果相加，得到的是一个形状为$H</em>{out}\times{W_{out}}$的二维数组。<br><br>&lt;/br&gt;<br><center><img src="https://ai-studio-static-online.cdn.bcebos.com/0e2fe8903925486d9f81196cc20694f3e49a5e74fca743679040605066d71d70" srcset="/img/loading.gif" width="800"></center><br><center><br>图7：多输入通道计算过程 <br>&lt;/center&gt;<br><br><br></center></p>
</li>
</ol>
<ul>
<li><strong>多输出通道场景</strong></li>
</ul>
<p>一般来说，卷积操作的输出特征图也会具有多个通道$C<em>{out}$，这时我们需要设计$C</em>{out}$个维度为$C<em>{in}\times{k_h}\times{k_w}$的卷积核，卷积核数组的维度是$C</em>{out}\times C_{in}\times{k_h}\times{k_w}$，如 <strong>图8</strong> 所示。</p>
<ol>
<li>对任一输出通道$c<em>{out} \in [0, C</em>{out})$，分别使用上面描述的形状为$C_{in}\times{k_h}\times{k_w}$的卷积核对输入图片做卷积。</li>
<li>将这$C<em>{out}$个形状为$H</em>{out}\times{W<em>{out}}$的二维数组拼接在一起，形成维度为$C</em>{out}\times{H<em>{out}}\times{W</em>{out}}$的三维数组。</li>
</ol>
<hr>
<p><strong>说明：</strong></p>
<p>通常将卷积核的输出通道数叫做卷积核的个数。</p>
<hr>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/61b04d11d29c4c98843199c4e85f5542bc174450b6e3466797e28819acdccfed" srcset="/img/loading.gif" width="800"></center></p>
<p><center><br>图8：多输出通道计算过程 <br></center><br><br><br></p>
<ul>
<li><strong>批量操作</strong></li>
</ul>
<p>在卷积神经网络的计算中，通常将多个样本放在一起形成一个mini-batch进行批量操作，即输入数据的维度是$N\times{C<em>{in}}\times{H</em>{in}}\times{W<em>{in}}$。由于会对每张图片使用同样的卷积核进行卷积操作，卷积核的维度与上面多输出通道的情况一样，仍然是$C</em>{out}\times C<em>{in}\times{k_h}\times{k_w}$，输出特征图的维度是$N\times{C</em>{out}}\times{H<em>{out}}\times{W</em>{out}}$，如 <strong>图9</strong> 所示。</p>
<p><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/0ff8dc78515b4aaf93abc3bfe225c8fde05d9b6d72f2480f8f559f684f2602f7" srcset="/img/loading.gif" width="800"></center></p>
<p><center><br>图9：批量操作 <br></center><br><br><br></p>
<h3 id="飞桨卷积API介绍"><a href="#飞桨卷积API介绍" class="headerlink" title="飞桨卷积API介绍"></a>飞桨卷积API介绍</h3><p>飞桨卷积算子对应的API是<a href="https://www.paddlepaddle.org.cn/documentation/docs/zh/api_cn/dygraph_cn/Conv2D_cn.html" target="_blank" rel="noopener">paddle.fluid.dygraph.nn.Conv2D</a>，用户可以直接调用API进行计算，也可以在此基础上修改。常用的参数如下：</p>
<ul>
<li>name_scope, 卷积层的名字，数据类型是字符串，可以是”conv1”或者”conv2”等形式。</li>
<li>num<em>filters, 输出通道数目，相当于上文中的$C</em>{out}$。</li>
<li>filter_size, 卷积核大小，可以是整数，比如3；或者是两个整数的list，例如[3, 3]。</li>
<li>stride, 步幅，可以是整数，比如2；或者是两个整数的list，例如[2, 2]。</li>
<li>padding, 填充大小，可以是整数，比如1；或者是两个整数的list，例如[1, 1]。</li>
<li>act, 激活函数，卷积操作完成之后使用此激活函数作用在神经元上。</li>
</ul>
<p>输入数据维度$[N, C<em>{in}, H</em>{in}, W<em>{in}]$，输出数据维度$[N, num_filters, H</em>{out}, W<em>{out}]$，权重参数$w$的维度$[num_filters, C</em>{in}, filter_size_h, filter_size_w]$，偏置参数$b$的维度是$[num_filters]$。</p>
<h3 id="卷积算子应用举例"><a href="#卷积算子应用举例" class="headerlink" title="卷积算子应用举例"></a>卷积算子应用举例</h3><p>下面介绍卷积算子在图片中应用的三个案例，并观察其计算结果。</p>
<p><strong>案例1——简单的黑白边界检测</strong></p>
<p>下面是使用Conv2D算子完成一个图像边界检测的任务。图像左边为光亮部分，右边为黑暗部分，需要检测出光亮跟黑暗的分界处。<br>可以设置宽度方向的卷积核为$[1, 0, -1]$，此卷积核会将宽度方向间隔为1的两个像素点的数值相减。当卷积核在图片上滑动的时候，如果它所覆盖的像素点位于亮度相同的区域，则左右间隔为1的两个像素点数值的差为0。只有当卷积核覆盖的像素点有的处于光亮区域，有的处在黑暗区域时，左右间隔为1的两个点像素值的差才不为0。将此卷积核作用到图片上，输出特征图上只有对应黑白分界线的地方像素值才不为0。具体代码如下所示，结果输出在下方的图案中。</p>
<pre><code class="lang-python">import matplotlib.pyplot as plt

import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D
from paddle.fluid.initializer import NumpyArrayInitializer
%matplotlib inline

with fluid.dygraph.guard():
    # 创建初始化权重参数w
    w = np.array([1, 0, -1], dtype=&#39;float32&#39;)
    # 将权重参数调整成维度为[cout, cin, kh, kw]的四维张量
    w = w.reshape([1, 1, 1, 3])
    # 创建卷积算子，设置输出通道数，卷积核大小，和初始化权重参数
    # filter_size = [1, 3]表示kh = 1, kw=3
    # 创建卷积算子的时候，通过参数属性param_attr，指定参数初始化方式
    # 这里的初始化方式时，从numpy.ndarray初始化卷积参数
    conv = Conv2D(&#39;conv&#39;, num_filters=1, filter_size=[1, 3],
            param_attr=fluid.ParamAttr(
              initializer=NumpyArrayInitializer(value=w)))

    # 创建输入图片，图片左边的像素点取值为1，右边的像素点取值为0
    img = np.ones([50,50], dtype=&#39;float32&#39;)
    img[:, 30:] = 0.
    # 将图片形状调整为[N, C, H, W]的形式
    x = img.reshape([1,1,50,50])
    # 将numpy.ndarray转化成paddle中的tensor
    x = fluid.dygraph.to_variable(x)
    # 使用卷积算子作用在输入图片上
    y = conv(x)
    # 将输出tensor转化为numpy.ndarray
    out = y.numpy()

f = plt.subplot(121)
f.set_title(&#39;input image&#39;, fontsize=15)
plt.imshow(img, cmap=&#39;gray&#39;)

f = plt.subplot(122)
f.set_title(&#39;output featuremap&#39;, fontsize=15)
# 卷积算子Conv2D输出数据形状为[N, C, H, W]形式
# 此处N, C=1，输出数据形状为[1, 1, H, W]，是4维数组
# 但是画图函数plt.imshow画灰度图时，只接受2维数组
# 通过numpy.squeeze函数将大小为1的维度消除
plt.imshow(out.squeeze(), cmap=&#39;gray&#39;)
plt.show()
</code></pre>
<p><img src="/2020/03/07/ConvNet/output_12_0.png" srcset="/img/loading.gif" alt="png"></p>
<pre><code class="lang-python"># 查看卷积层的参数
with fluid.dygraph.guard():
    # 通过 conv.parameters()查看卷积层的参数，返回值是list，包含两个元素
    print(conv.parameters())
    # 查看卷积层的权重参数名字和数值
    print(conv.parameters()[0].name, conv.parameters()[0].numpy())
    # 参看卷积层的偏置参数名字和数值
    print(conv.parameters()[1].name, conv.parameters()[1].numpy())
</code></pre>
<pre><code>[name conv/Conv2D_0.w_0, dtype: VarType.FP32 shape: [1L, 1L, 1L, 3L]     lod: {}
    dim: 1, 1, 1, 3
    layout: NCHW
    dtype: float
    data: [1 0 -1]
, name conv/Conv2D_0.b_0, dtype: VarType.FP32 shape: [1L]     lod: {}
    dim: 1
    layout: NCHW
    dtype: float
    data: [0]
]
(u&#39;conv/Conv2D_0.w_0&#39;, array([[[[ 1.,  0., -1.]]]], dtype=float32))
(u&#39;conv/Conv2D_0.b_0&#39;, array([0.], dtype=float32))
</code></pre><p><br><br><br><strong>案例2——图像中物体边缘检测</strong></p>
<p>上面展示的是一个人为构造出来的简单图片使用卷积检测明暗分界处的例子，对于真实的图片，也可以使用合适的卷积核对它进行操作，用来检测物体的外形轮廓，观察输出特征图跟原图之间的对应关系，如下代码所示：</p>
<pre><code class="lang-python">import matplotlib.pyplot as plt
from PIL import Image
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D
from paddle.fluid.initializer import NumpyArrayInitializer

img = Image.open(&#39;./work/images/section1/000000098520.jpg&#39;)
with fluid.dygraph.guard():
    # 设置卷积核参数
    w = np.array([[-1,-1,-1], [-1,8,-1], [-1,-1,-1]], dtype=&#39;float32&#39;)/8
    w = w.reshape([1, 1, 3, 3])
    # 由于输入通道数是3，将卷积核的形状从[1,1,3,3]调整为[1,3,3,3]
    w = np.repeat(w, 3, axis=1)
    # 创建卷积算子，输出通道数为1，卷积核大小为3x3，
    # 并使用上面的设置好的数值作为卷积核权重的初始化参数
    conv = Conv2D(&#39;conv&#39;, num_filters=1, filter_size=[3, 3], 
            param_attr=fluid.ParamAttr(
              initializer=NumpyArrayInitializer(value=w)))

    # 将读入的图片转化为float32类型的numpy.ndarray
    x = np.array(img).astype(&#39;float32&#39;)
    # 图片读入成ndarry时，形状是[H, W, 3]，
    # 将通道这一维度调整到最前面
    x = np.transpose(x, (2,0,1))
    # 将数据形状调整为[N, C, H, W]格式
    x = x.reshape(1, 3, img.height, img.width)
    x = fluid.dygraph.to_variable(x)
    y = conv(x)
    out = y.numpy()

plt.figure(figsize=(20, 10))
f = plt.subplot(121)
f.set_title(&#39;input image&#39;, fontsize=15)
plt.imshow(img)
f = plt.subplot(122)
f.set_title(&#39;output feature map&#39;, fontsize=15)
plt.imshow(out.squeeze(), cmap=&#39;gray&#39;)
plt.show()
</code></pre>
<p><img src="/2020/03/07/ConvNet/output_15_0.png" srcset="/img/loading.gif" alt="png"></p>
<p><br><br><br><strong>案例3——图像均值模糊</strong></p>
<p>另外一种比较常见的卷积核是用当前像素跟它邻域内的像素取平均，这样可以使图像上噪声比较大的点变得更平滑，如下代码所示：</p>
<pre><code class="lang-python">import matplotlib.pyplot as plt

from PIL import Image

import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D
from paddle.fluid.initializer import NumpyArrayInitializer

# 读入图片并转成numpy.ndarray
#img = Image.open(&#39;./images/section1/000000001584.jpg&#39;)
img = Image.open(&#39;./work/images/section1/000000355610.jpg&#39;).convert(&#39;L&#39;)
img = np.array(img)

# 换成灰度图

with fluid.dygraph.guard():
    # 创建初始化参数
    w = np.ones([1, 1, 5, 5], dtype = &#39;float32&#39;)/25
    conv = Conv2D(&#39;conv&#39;, num_filters=1, filter_size=[5, 5], 
            param_attr=fluid.ParamAttr(
              initializer=NumpyArrayInitializer(value=w)))

    x = img.astype(&#39;float32&#39;)
    x = x.reshape(1,1,img.shape[0], img.shape[1])
    x = fluid.dygraph.to_variable(x)
    y = conv(x)
    out = y.numpy()

plt.figure(figsize=(20, 12))
f = plt.subplot(121)
f.set_title(&#39;input image&#39;)
plt.imshow(img, cmap=&#39;gray&#39;)

f = plt.subplot(122)
f.set_title(&#39;output feature map&#39;)
out = out.squeeze()
plt.imshow(out, cmap=&#39;gray&#39;)

plt.show()
</code></pre>
<p><img src="/2020/03/07/ConvNet/output_17_0.png" srcset="/img/loading.gif" alt="png"></p>
<h2 id="池化（Pooling）"><a href="#池化（Pooling）" class="headerlink" title="池化（Pooling）"></a>池化（Pooling）</h2><p>池化是使用某一位置的相邻输出的总体统计特征代替网络在该位置的输出，其好处是当输入数据做出少量平移时，经过池化函数后的大多数输出还能保持不变。比如：当识别一张图像是否是人脸时，我们需要知道人脸左边有一只眼睛，右边也有一只眼睛，而不需要知道眼睛的精确位置，这时候通过约化某一片区域的像素点来得到总体统计特征会显得很有用。由于池化之后特征图会变得更小，如果后面连接的是全连接层，能有效的减小神经元的个数，节省存储空间并提高计算效率。<br>如 <strong>图10</strong> 所示，将一个$2\times 2$的区域池化成一个像素点。通常有两种方法，平均池化和最大池化。<br><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/ce54d634a89f4ddf96e363a4d8946941c4510b1ae09d47b3840f348a05e33f12" srcset="/img/loading.gif" width="600"></center></p>
<p><center><br>图10：池化 <br></center><br><br><br></p>
<ul>
<li>如图10（a）：平均池化。这里使用大小为$2\times2$的池化窗口，每次移动的步长也为2，对池化窗口内的元素数值取平均，得到相应的输出特征图的像素值。</li>
<li>如图10（b）：最大池化。对池化窗口覆盖区域内的元素取最大值，得到输出特征图的像素值。当池化窗口在图片上滑动时，会得到整张输出特征图。池化窗口的大小称为池化大小，用$k_h \times k_w$表示。在卷积神经网络中用的比较多的是窗口大小为$2 \times 2$，步长也为2的池化。</li>
</ul>
<p>与卷积核类似，池化窗口在图片上滑动时，每次移动的步长称为步幅，当宽和高方向的移动大小不一样时，分别用$s<em>h$和$s_w$表示。也可以对需要进行池化的图片进行填充，填充方式与卷积类似，假设在第一行之前填充$p</em>{h1}$行，在最后一行后面填充$p<em>{h2}$行。在第一列之前填充$p</em>{w1}$列，在最后一列之后填充$p_{w2}$列，则池化层的输出特征图大小为：</p>
<script type="math/tex; mode=display">H_{out} = \frac{H + p_{h1} + p_{h2} - k_h}{s_h} + 1</script><script type="math/tex; mode=display">W_{out} = \frac{W + p_{w1} + p_{w2} - k_w}{s_w} + 1</script><p>在卷积神经网络中，通常使用$2\times2$大小的池化窗口，步幅也使用2，填充为0，则输出特征图的尺寸为：</p>
<script type="math/tex; mode=display">H_{out} = \frac{H}{2}</script><script type="math/tex; mode=display">W_{out} = \frac{W}{2}</script><p>通过这种方式的池化，输出特征图的高和宽都减半，但通道数不会改变。</p>
<h2 id="ReLU激活函数"><a href="#ReLU激活函数" class="headerlink" title="ReLU激活函数"></a>ReLU激活函数</h2><p>前面介绍的网络结构中，普遍使用Sigmoid函数做激活函数。在神经网络发展的早期，Sigmoid函数用的比较多，而目前用的较多的激活函数是ReLU。这是因为Sigmoid函数在反向传播过程中，容易造成梯度的衰减。让我们仔细观察Sigmoid函数的形式，就能发现这一问题。</p>
<p>Sigmoid激活函数定义如下：</p>
<script type="math/tex; mode=display">y = \frac{1}{1 + e^{-x}}</script><p>ReLU激活函数的定义如下：</p>
<script type="math/tex; mode=display">y=\left\{
\begin{aligned}
0 & , & (x<0) \\
x & , & (x\ge 0)
\end{aligned}
\right.</script><p>下面的程序画出了Sigmoid和ReLU函数的曲线图：</p>
<pre><code class="lang-python"># ReLU和Sigmoid激活函数示意图
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches

plt.figure(figsize=(10, 5))

# 创建数据x
x = np.arange(-10, 10, 0.1)

# 计算Sigmoid函数
s = 1.0 / (1 + np.exp(0. - x))

# 计算ReLU函数
y = np.clip(x, a_min=0., a_max=None)

#####################################
# 以下部分为画图代码
f = plt.subplot(121)
plt.plot(x, s, color=&#39;r&#39;)
currentAxis=plt.gca()
plt.text(-9.0, 0.9, r&#39;$y=Sigmoid(x)$&#39;, fontsize=13)
currentAxis.xaxis.set_label_text(&#39;x&#39;, fontsize=15)
currentAxis.yaxis.set_label_text(&#39;y&#39;, fontsize=15)

f = plt.subplot(122)
plt.plot(x, y, color=&#39;g&#39;)
plt.text(-3.0, 9, r&#39;$y=ReLU(x)$&#39;, fontsize=13)
currentAxis=plt.gca()
currentAxis.xaxis.set_label_text(&#39;x&#39;, fontsize=15)
currentAxis.yaxis.set_label_text(&#39;y&#39;, fontsize=15)

plt.show()
</code></pre>
<p><img src="/2020/03/07/ConvNet/output_20_0.png" srcset="/img/loading.gif" alt="png"></p>
<p><strong>- 梯度消失现象</strong></p>
<p>在神经网络里面，将经过反向传播之后，梯度值衰减到接近于零的现象称作梯度消失现象。</p>
<p>从上面的函数曲线可以看出，当x为较大的正数的时候，Sigmoid函数数值非常接近于1，函数曲线变得很平滑，在这些区域Sigmoid函数的导数接近于零。当x为较小的负数的时候，Sigmoid函数值非常接近于0，函数曲线也很平滑，在这些区域Sigmoid函数的导数也接近于0。只有当x的取值在0附近时，Sigmoid函数的导数才比较大。可以对Sigmoid函数求导数，结果如下所示：</p>
<script type="math/tex; mode=display">\frac{dy}{dx} = -\frac{1}{(1+e^{-x})^2} \cdot \frac{d(e^{-x})}{dx} = \frac{1}{2 + e^x + e^{-x}}</script><p>从上面的式子可以看出，Sigmoid函数的导数$\frac{dy}{dx}$最大值为$\frac{1}{4}$。前向传播时，$y=Sigmoid(x)$；而在反向传播过程中，x的梯度等于y的梯度乘以Sigmoid函数的导数，如下所示：</p>
<script type="math/tex; mode=display">\frac{\partial{L}}{\partial{x}} = \frac{\partial{L}}{\partial{y}} \cdot \frac{\partial{y}}{\partial{x}}</script><p>使得x的梯度数值最大也不会超过y的梯度的$\frac{1}{4}$。</p>
<p>由于最开始是将神经网络的参数随机初始化的，x很有可能取值在数值很大或者很小的区域，这些地方都可能造成Sigmoid函数的导数接近于0，导致x的梯度接近于0；即使x取值在接近于0的地方，按上面的分析，经过Sigmoid函数反向传播之后，x的梯度不超过y的梯度的$\frac{1}{4}$，如果有多层网络使用了Sigmoid激活函数，则比较靠前的那些层梯度将衰减到非常小的值。</p>
<p>ReLU函数则不同，虽然在$x\lt 0$的地方，ReLU函数的导数为0。但是在$x\ge 0$的地方，ReLU函数的导数为1，能够将y的梯度完整的传递给x，而不会引起梯度消失。</p>
<h2 id="批归一化（Batch-Normalization）"><a href="#批归一化（Batch-Normalization）" class="headerlink" title="批归一化（Batch Normalization）"></a>批归一化（Batch Normalization）</h2><p><a href="https://arxiv.org/abs/1502.03167" target="_blank" rel="noopener">批归一化方法方法</a>（Batch Normalization，BatchNorm）是由Ioffe和Szegedy于2015年提出的，已被广泛应用在深度学习中，其目的是对神经网络中间层的输出进行标准化处理，使得中间层的输出更加稳定。</p>
<p>通常我们会对神经网络的数据进行标准化处理，处理后的样本数据集满足均值为0，方差为1的统计分布，这是因为当输入数据的分布比较固定时，有利于算法的稳定和收敛。对于深度神经网络来说，由于参数是不断更新的，即使输入数据已经做过标准化处理，但是对于比较靠后的那些层，其接收到的输入仍然是剧烈变化的，通常会导致数值不稳定，模型很难收敛。BatchNorm能够使神经网络中间层的输出变得更加稳定，并有如下三个优点：</p>
<ul>
<li><p>使学习快速进行（能够使用较大的学习率）</p>
</li>
<li><p>降低模型对初始值的敏感性</p>
</li>
<li><p>从一定程度上抑制过拟合</p>
</li>
</ul>
<p>BatchNorm主要思路是在训练时按mini-batch为单位，对神经元的数值进行归一化，使数据的分布满足均值为0，方差为1。具体计算过程如下：</p>
<p><strong>1. 计算mini-batch内样本的均值</strong></p>
<script type="math/tex; mode=display">\mu_B \leftarrow \frac{1}{m}\sum_{i=1}^mx^{(i)}</script><p>其中$x^{(i)}$表示mini-batch中的第$i$个样本。</p>
<p>例如输入mini-batch包含3个样本，每个样本有2个特征，分别是：</p>
<script type="math/tex; mode=display">x^{(1)} = (1,2), \ \ x^{(2)} = (3,6), \ \ x^{(3)} = (5,10)</script><p>对每个特征分别计算mini-batch内样本的均值：</p>
<script type="math/tex; mode=display">\mu_{B0} = \frac{1+3+5}{3} = 3, \ \ \ \mu_{B1} = \frac{2+6+10}{3} = 6</script><p>则样本均值是:</p>
<script type="math/tex; mode=display">\mu_{B} = (\mu_{B0}, \mu_{B1}) = (3, 6)</script><p><strong>2. 计算mini-batch内样本的方差</strong></p>
<script type="math/tex; mode=display">\sigma_B^2 \leftarrow \frac{1}{m}\sum_{i=1}^m(x^{(i)} - \mu_B)^2</script><p>上面的计算公式先计算一个批次内样本的均值$\mu_B$和方差$\sigma_B^2$，然后再对输入数据做归一化，将其调整成均值为0，方差为1的分布。</p>
<p>对于上述给定的输入数据$x^{(1)}, x^{(2)}, x^{(3)}$，可以计算出每个特征对应的方差：</p>
<script type="math/tex; mode=display">\sigma_{B0}^2 = \frac{1}{3} \cdot ((1-3)^2 + (3-3)^2 + (5-3)^2) = \frac{8}{3}</script><script type="math/tex; mode=display">\sigma_{B1}^2 = \frac{1}{3} \cdot ((2-6)^2 + (6-6)^2 + (10-6)^2) = \frac{32}{3}</script><p>则样本方差是：</p>
<script type="math/tex; mode=display">\sigma_{B}^2 = (\sigma_{B0}^2, \sigma_{B1}^2) = (\frac{8}{3}, \frac{32}{3})</script><p><strong>3. 计算标准化之后的输出</strong></p>
<script type="math/tex; mode=display">\hat{x}^{(i)} \leftarrow \frac{x^{(i)} - \mu_B}{\sqrt{(\sigma_B^2 + \epsilon)}}</script><p>其中$\epsilon$是一个微小值（例如$1e-7$），其主要作用是为了防止分母为0。</p>
<p>对于上述给定的输入数据$x^{(1)}, x^{(2)}, x^{(3)}$，可以计算出标准化之后的输出：</p>
<script type="math/tex; mode=display">\hat{x}^{(1)} = (\frac{1 - 3}{\sqrt{\frac{8}{3}}}, \ \ \frac{2 - 6}{\sqrt{\frac{32}{3}}}) = (-\sqrt{\frac{3}{2}}, \ \ -\sqrt{\frac{3}{2}})</script><script type="math/tex; mode=display">\hat{x}^{(2)} = (\frac{3 - 3}{\sqrt{\frac{8}{3}}}, \ \ \frac{6 - 6}{\sqrt{\frac{32}{3}}}) = (0, \ \ 0) \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \</script><script type="math/tex; mode=display">\hat{x}^{(3)} = (\frac{5 - 3}{\sqrt{\frac{8}{3}}}, \ \ \frac{10 - 6}{\sqrt{\frac{32}{3}}}) = (\sqrt{\frac{3}{2}}, \ \ \sqrt{\frac{3}{2}}) \ \ \ \</script><ul>
<li>读者可以自行验证由$\hat{x}^{(1)}, \hat{x}^{(2)}, \hat{x}^{(3)}$构成的mini-batch，是否满足均值为0，方差为1的分布。</li>
</ul>
<p>如果强行限制输出层的分布是标准化的，可能会导致某些特征模式的丢失，所以在标准化之后，BatchNorm会紧接着对数据做缩放和平移。</p>
<script type="math/tex; mode=display">y_i \leftarrow \gamma \hat{x_i} + \beta</script><p>其中$\gamma$和$\beta$是可学习的参数，可以赋初始值$\gamma = 1, \beta = 0$，在训练过程中不断学习调整。</p>
<p>上面列出的是BatchNorm方法的计算逻辑，下面针对两种类型的输入数据格式分别进行举例。飞桨支持输入数据的维度大小为2、3、4、5四种情况，这里给出的是维度大小为2和4的示例。</p>
<ul>
<li><strong>示例一：</strong> 当输入数据形状是$[N, K]$时，一般对应全连接层的输出，示例代码如下所示。 </li>
</ul>
<p>这种情况下会分别对K的每一个分量计算N个样本的均值和方差，数据和参数对应如下：</p>
<ul>
<li>输入 x, [N, K]</li>
<li>输出 y, [N, K]</li>
<li>均值 $\mu_B$，[K, ]</li>
<li>方差 $\sigma_B^2$, [K, ]</li>
<li>缩放参数$\gamma$, [K, ]</li>
<li>平移参数$\beta$, [K, ]</li>
</ul>
<pre><code class="lang-python"># 输入数据形状是 [N, K]时的示例
import numpy as np

import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import BatchNorm
# 创建数据
data = np.array([[1,2,3], [4,5,6], [7,8,9]]).astype(&#39;float32&#39;)
# 使用BatchNorm计算归一化的输出
with fluid.dygraph.guard():
    # 输入数据维度[N, K]，num_channels等于K
    bn = BatchNorm(&#39;bn&#39;, num_channels=3)    
    x = fluid.dygraph.to_variable(data)
    y = bn(x)
    print(&#39;output of BatchNorm Layer: \n {}&#39;.format(y.numpy()))

# 使用Numpy计算均值、方差和归一化的输出
# 这里对第0个特征进行验证
a = np.array([1,4,7])
a_mean = a.mean()
a_std = a.std()
b = (a - a_mean) / a_std
print(&#39;std {}, mean {}, \n output {}&#39;.format(a_mean, a_std, b))

# 建议读者对第1和第2个特征进行验证，观察numpy计算结果与paddle计算结果是否一致
</code></pre>
<pre><code>output of BatchNorm Layer: 
 [[-1.2247438 -1.2247438 -1.2247438]
 [ 0.         0.         0.       ]
 [ 1.2247438  1.2247438  1.2247438]]
std 4.0, mean 2.44948974278, 
 output [-1.22474487  0.          1.22474487]
</code></pre><ul>
<li><strong>示例二：</strong> 当输入数据形状是$[N, C, H, W]$时， 一般对应卷积层的输出，示例代码如下所示。</li>
</ul>
<p>这种情况下会沿着C这一维度进行展开，分别对每一个通道计算N个样本中总共$N\times H \times W$个像素点的均值和方差，数据和参数对应如下：</p>
<ul>
<li>输入 x, [N, C, H, W]</li>
<li>输出 y, [N, C, H, W]</li>
<li>均值 $\mu_B$，[C, ]</li>
<li>方差 $\sigma_B^2$, [C, ]</li>
<li>缩放参数$\gamma$, [C, ]</li>
<li>平移参数$\beta$, [C, ]</li>
</ul>
<hr>
<p><strong>小窍门：</strong></p>
<p>可能有读者会问：“BatchNorm里面不是还要对标准化之后的结果做仿射变换吗，怎么使用Numpy计算的结果与BatchNorm算子一致？” 这是因为BatchNorm算子里面自动设置初始值$\gamma = 1, \beta = 0$，这时候仿射变换相当于是恒等变换。在训练过程中这两个参数会不断的学习，这时仿射变换就会起作用。</p>
<hr>
<pre><code class="lang-python"># 输入数据形状是[N, C, H, W]时的batchnorm示例
import numpy as np

import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import BatchNorm

# 设置随机数种子，这样可以保证每次运行结果一致
np.random.seed(100)
# 创建数据
data = np.random.rand(2,3,3,3).astype(&#39;float32&#39;)
# 使用BatchNorm计算归一化的输出
with fluid.dygraph.guard():
    # 输入数据维度[N, C, H, W]，num_channels等于C
    bn = BatchNorm(&#39;bn&#39;, num_channels=3)
    x = fluid.dygraph.to_variable(data)
    y = bn(x)
    print(&#39;input of BatchNorm Layer: \n {}&#39;.format(x.numpy()))
    print(&#39;output of BatchNorm Layer: \n {}&#39;.format(y.numpy()))

# 取出data中第0通道的数据，
# 使用numpy计算均值、方差及归一化的输出
a = data[:, 0, :, :]
a_mean = a.mean()
a_std = a.std()
b = (a - a_mean) / a_std
print(&#39;channel 0 of input data: \n {}&#39;.format(a))
print(&#39;std {}, mean {}, \n output: \n {}&#39;.format(a_mean, a_std, b))

# 提示：这里通过numpy计算出来的输出
# 与BatchNorm算子的结果略有差别，
# 因为在BatchNorm算子为了保证数值的稳定性，
# 在分母里面加上了一个比较小的浮点数epsilon=1e-05
</code></pre>
<pre><code>input of BatchNorm Layer: 
 [[[[0.54340494 0.2783694  0.4245176 ]
   [0.84477615 0.00471886 0.12156912]
   [0.67074907 0.82585275 0.13670659]]

  [[0.5750933  0.89132196 0.20920213]
   [0.18532822 0.10837689 0.21969749]
   [0.9786238  0.8116832  0.17194101]]

  [[0.81622475 0.27407375 0.4317042 ]
   [0.9400298  0.81764936 0.33611196]
   [0.17541045 0.37283206 0.00568851]]]
</code></pre><p>​<br>​     [[[0.25242636 0.7956625  0.01525497]<br>​       [0.5988434  0.6038045  0.10514768]<br>​       [0.38194343 0.03647606 0.89041156]]<br>​<br>      [[0.98092085 0.05994199 0.89054596]<br>       [0.5769015  0.7424797  0.63018394]<br>       [0.5818422  0.02043913 0.21002658]]</p>
<pre><code>  [[0.5446849  0.76911515 0.25069523]
   [0.2858957  0.8523951  0.9750065 ]
   [0.8848533  0.35950786 0.59885895]]]]
output of BatchNorm Layer: 
 [[[[ 0.41260773 -0.46198368  0.02029113]
   [ 1.4071033  -1.3650038  -0.9794093 ]
   [ 0.83283097  1.344658   -0.9294571 ]]

  [[ 0.25201762  1.2038352  -0.8492796 ]
   [-0.92113775 -1.1527538  -0.81768954]
   [ 1.4666054   0.9641302  -0.9614319 ]]

  [[ 0.9541145  -0.9075854  -0.366296  ]
   [ 1.3792504   0.9590065  -0.69455147]
   [-1.2463866  -0.56845784 -1.8291972 ]]]
</code></pre><p>​<br>​     [[[-0.5475932   1.2450331  -1.3302356 ]<br>​       [ 0.5955492   0.6119205  -1.0335984 ]<br>​       [-0.12019946 -1.2602081   1.5576957 ]]<br>​<br>      [[ 1.4735192  -1.2985382   1.2014996 ]<br>       [ 0.25746003  0.75583434  0.41783503]<br>       [ 0.272331   -1.4174379  -0.84679806]]</p>
<pre><code>  [[ 0.02166999  0.7923442  -0.9878652 ]
   [-0.8669898   1.0783204   1.4993575 ]
   [ 1.189779   -0.614212    0.20769906]]]]
channel 0 of input data: 
 [[[0.54340494 0.2783694  0.4245176 ]
  [0.84477615 0.00471886 0.12156912]
  [0.67074907 0.82585275 0.13670659]]

 [[0.25242636 0.7956625  0.01525497]
  [0.5988434  0.6038045  0.10514768]
  [0.38194343 0.03647606 0.89041156]]]
std 0.418368607759, mean 0.303022772074, 
 output: 
 [[[ 0.41263014 -0.46200886  0.02029219]
  [ 1.4071798  -1.3650781  -0.9794626 ]
  [ 0.8328762   1.3447311  -0.92950773]]

 [[-0.54762304  1.2451009  -1.3303081 ]
  [ 0.5955816   0.61195374 -1.0336547 ]
  [-0.12020606 -1.2602768   1.5577804 ]]]
</code></pre><p><strong>- 预测时使用BatchNorm</strong></p>
<p>上面介绍了在训练过程中使用BatchNorm对一批样本进行归一化的方法，但如果使用同样的方法对需要预测的一批样本进行归一化，则预测结果会出现不确定性。</p>
<p>例如样本A、样本B作为一批样本计算均值和方差，与样本A、样本C和样本D作为一批样本计算均值和方差，得到的结果一般来说是不同的。那么样本A的预测结果就会变得不确定，这对预测过程来说是不合理的。解决方法是在训练过程中将大量样本的均值和方差保存下来，预测时直接使用保存好的值而不再重新计算。实际上，在BatchNorm的具体实现中，训练时会计算均值和方差的移动平均值。在飞桨中，默认是采用如下方式计算：</p>
<script type="math/tex; mode=display">saved\_\mu_B \leftarrow \ saved\_\mu_B \times 0.9 + \mu_B \times (1 - 0.9)</script><script type="math/tex; mode=display">saved\_\sigma_B^2 \leftarrow \ saved\_\sigma_B^2 \times 0.9 + \sigma_B^2 \times (1 - 0.9)</script><p>在训练过程的最开始将$saved_\mu<em>B$和$saved\</em>\sigma<em>B^2$设置为0，每次输入一批新的样本，计算出$\mu_B$和$\sigma_B^2$，然后通过上面的公式更新$saved\</em>\mu<em>B$和$saved\</em>\sigma<em>B^2$，在训练的过程中不断的更新它们的值，并作为BatchNorm层的参数保存下来。预测的时候将会加载参数$saved\</em>\mu<em>B$和$saved\</em>\sigma_B^2$，用他们来代替$\mu_B$和$\sigma_B^2$。</p>
<h2 id="丢弃法（Dropout）"><a href="#丢弃法（Dropout）" class="headerlink" title="丢弃法（Dropout）"></a>丢弃法（Dropout）</h2><p>丢弃法（Dropout）是深度学习中一种常用的抑制过拟合的方法，其做法是在神经网络学习过程中，随机删除一部分神经元。训练时，随机选出一部分神经元，将其输出设置为0，这些神经元将不对外传递信号。</p>
<p><strong>图11</strong> 是Dropout示意图，左边是完整的神经网络，右边是应用了Dropout之后的网络结构。应用Dropout之后，会将标了$\times$的神经元从网络中删除，让它们不向后面的层传递信号。在学习过程中，丢弃哪些神经元是随机决定，因此模型不会过度依赖某些神经元，能一定程度上抑制过拟合。<br><br><br></p>
<p><center><img src="https://ai-studio-static-online.cdn.bcebos.com/e656dd0ed5064ef6bf6a9fba1515320548bd103f444b4d3f9c89f930e6b90d75" srcset="/img/loading.gif" width="700"></center></p>
<p><center><br>图11 Dropout示意图 <br></center><br><br><br></p>
<p>在预测场景时，会向前传递所有神经元的信号，可能会引出一个新的问题：训练时由于部分神经元被随机丢弃了，输出数据的总大小会变小了。比如：计算其$L1$范数会比不使用Dropout时变小，但是预测时却没有丢弃神经元，这将导致训练和预测时数据的分布不一样。为了解决这个问题，飞桨支持如下两种方法：</p>
<ul>
<li>1 <strong>downgrade_in_infer</strong></li>
</ul>
<p>训练时以比例$r$随机丢弃一部分神经元，不向后传递它们的信号；预测时向后传递所有神经元的信号，但是将每个神经元上的数值乘以 $(1 - r)$。</p>
<ul>
<li>2 <strong>upscale_in_train</strong></li>
</ul>
<p>训练时以比例$r$随机丢弃一部分神经元，不向后传递它们的信号，但是将那些被保留的神经元上的数值除以 $(1 - r)$；预测时向后传递所有神经元的信号，不做任何处理。</p>
<p>在飞桨<a href="https://www.paddlepaddle.org.cn/documentation/docs/zh/api_cn/layers_cn/dropout_cn.html#dropout" target="_blank" rel="noopener">dropout API</a>中，paddle.fluid.layers.dropout通过dropout_implementation参数来指定用哪种方式对神经元进行操作，dropout_implementation参数的可选值是’downgrade_in_infer’或’upscale_in_train’，缺省值是’downgrade_in_infer’。</p>
<hr>
<p><strong>说明：</strong></p>
<p>不同框架中dropout的默认处理方式可能不一样，读者可以查看其API以确认用的是哪种方式。</p>
<hr>
<p>飞桨<a href="https://www.paddlepaddle.org.cn/documentation/docs/zh/api_cn/layers_cn/dropout_cn.html#dropout" target="_blank" rel="noopener">dropout API</a>包含的主要参数如下：</p>
<ul>
<li>x，数据类型是Tensor，需要采用丢弃法进行操作的对象。</li>
<li>dropout_prob，对x中元素进行丢弃的概率。</li>
<li>is_test，是否运行在测试阶段，由于dropout在训练和测试阶段表现不一样，通过此参数控制其表现，默认值为False。</li>
<li>dropout_implementation，丢弃法的实现方式，有’downgrade_in_infer’和’upscale_in_train’两种，具体情况请见上面的说明，默认是’downgrade_in_infer’。</li>
</ul>
<p>下面这段程序展示了经过dropout之后输出数据的形式。</p>
<pre><code class="lang-python"># dropout操作
import numpy as np

import paddle
import paddle.fluid as fluid

# 设置随机数种子，这样可以保证每次运行结果一致
np.random.seed(100)
# 创建数据[N, C, H, W]，一般对应卷积层的输出
data1 = np.random.rand(2,3,3,3).astype(&#39;float32&#39;)
# 创建数据[N, K]，一般对应全连接层的输出
data2 = np.arange(1,13).reshape([-1, 3]).astype(&#39;float32&#39;)
# 使用dropout作用在输入数据上
with fluid.dygraph.guard():
    x1 = fluid.dygraph.to_variable(data1)
    out1_1 = fluid.layers.dropout(x1, dropout_prob=0.5, is_test=False)
    out1_2 = fluid.layers.dropout(x1, dropout_prob=0.5, is_test=True)

    x2 = fluid.dygraph.to_variable(data2)
    out2_1 = fluid.layers.dropout(x2, dropout_prob=0.5, \
                    dropout_implementation=&#39;upscale_in_train&#39;)
    out2_2 = fluid.layers.dropout(x2, dropout_prob=0.5, \
                    dropout_implementation=&#39;upscale_in_train&#39;, is_test=True)

    print(&#39;x1 {}, \n out1_1 \n {}, \n out1_2 \n {}&#39;.format(data1, out1_1.numpy(),  out1_2.numpy()))
    print(&#39;x2 {}, \n out2_1 \n {}, \n out2_2 \n {}&#39;.format(data2, out2_1.numpy(),  out2_2.numpy()))
</code></pre>
<pre><code>x1 [[[[0.54340494 0.2783694  0.4245176 ]
   [0.84477615 0.00471886 0.12156912]
   [0.67074907 0.82585275 0.13670659]]

  [[0.5750933  0.89132196 0.20920213]
   [0.18532822 0.10837689 0.21969749]
   [0.9786238  0.8116832  0.17194101]]

  [[0.81622475 0.27407375 0.4317042 ]
   [0.9400298  0.81764936 0.33611196]
   [0.17541045 0.37283206 0.00568851]]]
</code></pre><p>​<br>​     [[[0.25242636 0.7956625  0.01525497]<br>​       [0.5988434  0.6038045  0.10514768]<br>​       [0.38194343 0.03647606 0.89041156]]<br>​<br>      [[0.98092085 0.05994199 0.89054596]<br>       [0.5769015  0.7424797  0.63018394]<br>       [0.5818422  0.02043913 0.21002658]]</p>
<pre><code>  [[0.5446849  0.76911515 0.25069523]
   [0.2858957  0.8523951  0.9750065 ]
   [0.8848533  0.35950786 0.59885895]]]], 
 out1_1 
 [[[[0.54340494 0.2783694  0.4245176 ]
   [0.         0.         0.        ]
   [0.67074907 0.         0.        ]]

  [[0.5750933  0.89132196 0.20920213]
   [0.18532822 0.         0.21969749]
   [0.9786238  0.         0.17194101]]

  [[0.         0.         0.        ]
   [0.         0.81764936 0.33611196]
   [0.17541045 0.         0.        ]]]
</code></pre><p>​<br>​     [[[0.25242636 0.         0.01525497]<br>​       [0.         0.6038045  0.        ]<br>​       [0.38194343 0.         0.        ]]<br>​<br>      [[0.98092085 0.05994199 0.        ]<br>       [0.         0.7424797  0.63018394]<br>       [0.         0.02043913 0.21002658]]</p>
<pre><code>  [[0.         0.         0.        ]
   [0.         0.         0.9750065 ]
   [0.8848533  0.         0.59885895]]]], 
 out1_2 
 [[[[0.27170247 0.1391847  0.2122588 ]
   [0.42238808 0.00235943 0.06078456]
   [0.33537453 0.41292638 0.0683533 ]]

  [[0.28754666 0.44566098 0.10460106]
   [0.09266411 0.05418845 0.10984875]
   [0.4893119  0.4058416  0.08597051]]

  [[0.40811238 0.13703687 0.2158521 ]
   [0.4700149  0.40882468 0.16805598]
   [0.08770522 0.18641603 0.00284425]]]
</code></pre><p>​<br>​     [[[0.12621318 0.39783126 0.00762749]<br>​       [0.2994217  0.30190226 0.05257384]<br>​       [0.19097172 0.01823803 0.44520578]]<br>​<br>      [[0.49046043 0.02997099 0.44527298]<br>       [0.28845075 0.37123984 0.31509197]<br>       [0.2909211  0.01021957 0.10501329]]</p>
<pre><code>  [[0.27234244 0.38455757 0.12534761]
   [0.14294785 0.42619756 0.48750326]
   [0.44242665 0.17975393 0.29942948]]]]
x2 [[ 1.  2.  3.]
 [ 4.  5.  6.]
 [ 7.  8.  9.]
 [10. 11. 12.]], 
 out2_1 
 [[ 2.  4.  6.]
 [ 8.  0. 12.]
 [14.  0.  0.]
 [ 0.  0. 24.]], 
 out2_2 
 [[ 1.  2.  3.]
 [ 4.  5.  6.]
 [ 7.  8.  9.]
 [10. 11. 12.]]
</code></pre><h1 id="小结"><a href="#小结" class="headerlink" title="小结"></a>小结</h1><p>学习完这些概念，您就具备了搭建卷积神经网络的基础。下一节，我们将应用这些基础模块，一起完成图像分类中的典型应用 — 医疗图像中的眼疾筛查任务的模型搭建。</p>
<h1 id="作业"><a href="#作业" class="headerlink" title="作业"></a>作业</h1><h2 id="7-1-计算卷积中一共有多少次乘法和加法操作"><a href="#7-1-计算卷积中一共有多少次乘法和加法操作" class="headerlink" title="7-1 计算卷积中一共有多少次乘法和加法操作"></a>7-1 计算卷积中一共有多少次乘法和加法操作</h2><p>输入数据形状是$[10, 3, 224, 224]$，卷积核$k_h = k_w = 3$，输出通道数为$64$，步幅$stride=1$，填充$p_h = p_w = 1$。</p>
<p>则完成这样一个卷积，一共需要做多少次乘法和加法操作？</p>
<ul>
<li>提示</li>
</ul>
<p>先看输出一个像素点需要做多少次乘法和加法操作，然后再计算总共需要的操作次数。</p>
<ul>
<li>提交方式</li>
</ul>
<p>请回复乘法和加法操作的次数，例如：乘法1000，加法1000</p>
<h2 id="7-2-计算网络层的输出数据和参数的形状"><a href="#7-2-计算网络层的输出数据和参数的形状" class="headerlink" title="7-2 计算网络层的输出数据和参数的形状"></a>7-2 计算网络层的输出数据和参数的形状</h2><p>网络结构定义如下面的代码所示，输入数据形状是$[10, 3, 224, 224]$，</p>
<p>请分别计算每一层的输出数据形状，以及各层包含的参数形状</p>
<pre><code class="lang-python"># 定义 SimpleNet 网络结构
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, FC

class SimpleNet(fluid.dygraph.Layer):
    def __init__(self, name_scope, num_classes=1):
        super(LeNet, self).__init__(name_scope)
        name_scope = self.full_name()
        self.conv1 = Conv2D(name_scope, num_filters=6, filter_size=5, stride=1, padding=2, act=&#39;relu&#39;)
        self.pool1 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type=&#39;max&#39;)
        self.conv2 = Conv2D(name_scope, num_filters=16, filter_size=5, stride=1, padding=2, act=&#39;relu&#39;)
        self.pool2 = Pool2D(name_scope, pool_size=2, pool_stride=2, pool_type=&#39;max&#39;)
        self.fc1 = FC(name_scope, size=64, act=&#39;sigmoid&#39;)
        self.fc2 = FC(name_scope, size=num_classes)        

    def forward(self, x):
        x = self.conv1(x)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = self.fc1(x)
        x = self.fc2(x)
        return x
</code></pre>
<ul>
<li>提示，第一层卷积$conv1$，各项参数如下：</li>
</ul>
<script type="math/tex; mode=display">C_{in} = 3, C_{out} = 6, k_h = k_w = 5, p_h = p_w = 2, stride = 1</script><p>则卷积核权重参数$w$的形状是：$[C<em>{out}, C</em>{in}, k_h, K_w] = [6, 3, 5, 5]$，个数$6\times3\times5\times5 = 450$</p>
<p>偏置参数$b$的形状是：$[C_{out}]$，偏置参数的个数是6</p>
<p>输出特征图的大小是：</p>
<script type="math/tex; mode=display">H_{out} = 224 + 2\times2 - 5 + 1 = 224, \ \ \ \ \ W_{out} = 224 + 2\times2 - 5 + 1 = 224</script><p>输出特征图的形状是$[N, C<em>{out}, H</em>{out}, W_{out}] = [10, 6, 224, 224]$</p>
<p>请将下面的表格补充完整：</p>
<div class="table-container">
<table>
<thead>
<tr>
<th style="text-align:center">名称</th>
<th style="text-align:center">w形状</th>
<th style="text-align:center">w参数个数</th>
<th style="text-align:center">b形状</th>
<th style="text-align:center">b参数个数</th>
<th style="text-align:center">输出形状</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:center">conv1</td>
<td style="text-align:center">[6,3,5,5]</td>
<td style="text-align:center">450</td>
<td style="text-align:center">[6]</td>
<td style="text-align:center">6</td>
<td style="text-align:center">[10, 6, 224, 224]</td>
</tr>
<tr>
<td style="text-align:center">pool1</td>
<td style="text-align:center">无</td>
<td style="text-align:center">无</td>
<td style="text-align:center">无</td>
<td style="text-align:center">无</td>
<td style="text-align:center">[10, 6, 112, 112]</td>
</tr>
<tr>
<td style="text-align:center">conv2</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:center">pool2</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:center">fc1</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
<tr>
<td style="text-align:center">fc2</td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
<td style="text-align:center"></td>
</tr>
</tbody>
</table>
</div>

            <hr>
          </div>
          <br>
          <div>
            <p>
            
            
              <span>
                <i class="iconfont icon-tag"></i>
                
                  <a class="hover-with-bg" href="/tags/%E5%8D%B7%E7%A7%AF%E7%A5%9E%E7%BB%8F%E7%BD%91%E7%BB%9C">卷积神经网络</a>
                
              </span>
            
            </p>
            
              <p class="note note-warning">本博客所有文章除特别声明外，均采用 <a href="https://zh.wikipedia.org/wiki/Wikipedia:CC_BY-SA_3.0%E5%8D%8F%E8%AE%AE%E6%96%87%E6%9C%AC" target="_blank" rel="nofollow noopener noopener">CC BY-SA 3.0协议</a> 。转载请注明出处！</p>
            
          </div>
        </div>
      </div>
    </div>
    <div class="d-none d-lg-block col-lg-2 toc-container">
      
  <div id="toc">
    <p class="h5"><i class="far fa-list-alt"></i>&nbsp;目录</p>
    <div id="tocbot"></div>
  </div>

    </div>
  </div>
</div>

<!-- custom -->


<!-- Comments -->
<div class="col-lg-7 mx-auto nopadding-md">
  <div class="container comments mx-auto" id="comments">
    
      <br><br>
      
      
  <!--PC和WAP自适应版-->
  <div id="SOHUCS" sid='http://kali20gakki.gitee.io/2020/03/07/ConvNet/'></div>
  <script type="text/javascript">
    (function () {
      var appid = 'cytuKUrVx';
      var conf = '';
      var width = window.innerWidth || document.documentElement.clientWidth;
      if (width < 960) {
        var head = document.getElementsByTagName('head')[0] || document.head || document.documentElement;
        var script = document.createElement('script');
        script.type = 'text/javascript';
        script.charset = 'utf-8';
        script.id = 'changyan_mobile_js';
        script.src = 'https://changyan.sohu.com/upload/mobile/wap-js/changyan_mobile.js?client_id=' + appid + '&conf=' + conf;
        head.appendChild(script);
      } else {
        var loadJs = function (d, a) {
          var c = document.getElementsByTagName('head')[0] || document.head || document.documentElement;
          var b = document.createElement('script');
          b.setAttribute('type', 'text/javascript');
          b.setAttribute('charset', 'UTF-8');
          b.setAttribute('src', d);
          if (typeof a === 'function') {
            if (window.attachEvent) {
              b.onreadystatechange = function () {
                var e = b.readyState;
                if (e === 'loaded' || e === 'complete') {
                  b.onreadystatechange = null;
                  a();
                }
              };
            } else {
              b.onload = a;
            }
          }
          c.appendChild(b);
        };
        loadJs('https://changyan.sohu.com/upload/changyan.js', function () {
          window.changyan.api.config({ appid: appid, conf: conf });
        });
      }
    })(); </script>


    
  </div>
</div>

    
  </main>

  
    <a class="z-depth-1" id="scroll-top-button" href="#" role="button">
      <i class="fa fa-chevron-up scroll-top-arrow" aria-hidden="true"></i>
    </a>
  

  
    <div class="modal fade" id="modalSearch" tabindex="-1" role="dialog" aria-labelledby="ModalLabel"
     aria-hidden="true">
  <div class="modal-dialog modal-dialog-scrollable modal-lg" role="document">
    <div class="modal-content">
      <div class="modal-header text-center">
        <h4 class="modal-title w-100 font-weight-bold">搜索</h4>
        <button type="button" id="local-search-close" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">&times;</span>
        </button>
      </div>
      <div class="modal-body mx-3">
        <div class="md-form mb-5">
          <input type="text" id="local-search-input" class="form-control validate">
          <label data-error="x" data-success="v"
                 for="local-search-input">关键词</label>
        </div>
        <div class="list-group" id="local-search-result"></div>
      </div>
    </div>
  </div>
</div>
  

  <footer class="mt-5">
  <div class="text-center py-3">
    <a href="https://hexo.io" target="_blank" rel="nofollow noopener"><b>Hexo</b></a>
    <i class="iconfont icon-love"></i>
    <a href="https://github.com/fluid-dev/hexo-theme-fluid" target="_blank" rel="nofollow noopener"> <b>Fluid</b></a>
    <br>

    
  
    <!-- 不蒜子统计PV -->
    
    &nbsp;<span id="busuanzi_container_site_pv"></span>总访问量 
          <span id="busuanzi_value_site_pv"></span> 次&nbsp;
  
  
    <!-- 不蒜子统计UV -->
    
    &nbsp;<span id="busuanzi_container_site_uv"></span>总访客数 
            <span id="busuanzi_value_site_uv"></span> 人&nbsp;
  
  <br>



    


    <!-- cnzz Analytics icon -->
    

  </div>
</footer>

<!-- SCRIPTS -->
<script src="/lib/jquery/jquery.min.js" ></script>
<script src="/lib/popper/popper.min.js" ></script>
<script src="/lib/bootstrap/js/bootstrap.min.js" ></script>
<script src="/lib/mdbootstrap/js/mdb.min.js" ></script>
<script src="/js/main.js" ></script>


  <script src="/js/lazyload.js" ></script>



  <script src="/js/post.js" ></script>
  
    <script src="/lib/tocbot/tocbot.min.js" ></script>
    <script>
      $(document).ready(function () {
        tocbot.init({
          tocSelector: '#tocbot',
          contentSelector: '.post-content',
          headingSelector: 'h1,h2,h3,h4,h5,h6',
          linkClass: 'tocbot-link',
          activeLinkClass: 'tocbot-active-link',
          listClass: 'tocbot-list',
          isCollapsedClass: 'tocbot-is-collapsed',
          collapsibleClass: 'tocbot-is-collapsible',
          scrollSmooth: true,
        });
      });
    </script>
  



  <script src="/lib/smoothscroll/SmoothScroll.min.js" ></script>



  <script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js" ></script>


<!-- Plugins -->


  
    <!-- Baidu Analytics -->
    <script>
      var _hmt = _hmt || [];
      (function () {
        var hm = document.createElement("script");
        hm.src = "https://hm.baidu.com/hm.js?0ed95453e0e994f44b9546c1f34184e4";
        var s = document.getElementsByTagName("script")[0];
        s.parentNode.insertBefore(hm, s);
      })();
    </script>
  

  

  

  

  <!-- cnzz Analytics -->
  



  <script src="/lib/prettify/prettify.min.js" ></script>
  <script>
    $(document).ready(function () {
      $('pre').addClass('prettyprint  linenums');
      prettyPrint();
    })
  </script>



  <script src="/lib/typed/typed.min.js" ></script>
  <script>
    var typed = new Typed('#subtitle', {
      strings: [
        '  ',
        "卷积神经网络&nbsp;",
      ],
      cursorChar: "|",
      typeSpeed: 100,
      loop: false,
    });
    typed.stop();
    $(document).ready(function () {
      $(".typed-cursor").addClass("h2");
      typed.start();
    });
  </script>



  <script src="/lib/anchor/anchor.min.js" ></script>
  <script>
    anchors.options = {
      placement: "right",
      visible: "hover",
      
      icon: "§"
      
    };
    var el = "h1,h2,h3,h4,h5,h6".split(",");
    var res = [];
    for (item of el) {
      res.push(".markdown-body > " + item)
    }
    anchors.add(res.join(", "))
  </script>



  <script src="/js/local-search.js" ></script>
  <script>
    var path = "/local-search.xml";
    var inputArea = document.querySelector("#local-search-input");
    inputArea.onclick = function () {
      getSearchFile(path);
      this.onclick = null
    }
  </script>



  <script src="/lib/fancybox/jquery.fancybox.min.js" ></script>
  <script>
    $("#post img:not(.no-zoom img, img[no-zoom])").each(
      function () {
        var element = document.createElement("a");
        $(element).attr("data-fancybox", "images");
        $(element).attr("href", $(this).attr("src"));
        $(this).wrap(element);
      }
    );
  </script>



  

  
    <!-- MathJax -->
    <script type="text/x-mathjax-config">
      MathJax.Hub.Config({
          tex2jax: {
              inlineMath: [ ['$','$'], ["\\(","\\)"]  ],
              processEscapes: true,
              skipTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code']
          }
      });

      MathJax.Hub.Queue(function() {
          var all = MathJax.Hub.getAllJax(), i;
          for(i=0; i < all.length; i += 1) {
              all[i].SourceElement().parentNode.className += ' has-jax';
          }
      });

    </script>

    <script src="https://cdn.staticfile.org/mathjax/2.7.6/MathJax.js?config=TeX-MML-AM_CHTML" ></script>

  










</body>
</html>
